﻿// dataGrid.js - 封装公共 DataGrid 初始化
function initializeDataGrid(config) {
    // 设置默认的datagrid选择器
    const datagridSelector = config.datagridSelector || '#datagrid';

    $(datagridSelector).datagrid({
        url: config.url || '',  // 数据加载的 URL
        fit: true,            // 表格宽高自适应父容器
        queryParams: config.queryParams || {}, // 查询参数，以键值对形式传递给远程数据接口。
        fitColumns: config.fitColumns || true,     // 启用列宽自动适配
        striped: config.striped || true,        // 斑马线效果
        method: config.method || 'post',        //指定post请求
        singleSelect: false,   // 多选模式
        checkOnSelect: true,   // 选中行时，checkbox自动选中
        selectOnCheck: true,   // 勾选复选框时，自动选择行
        remoteSort: true,       //远程排序
        emptyMsg: config.emptyMsg || '',     //当 DataGrid 中没有数据时，会在表格中间显示"暂无数据"的提示。
        view: config.view || (config.detailFormatter ? 'detailview' : undefined),
        pagination: true,     // 启用分页功能
        showFooter: true,      // 启用页脚功能
        sortName: config.sortName || '',   //排序的字段
        sortOrder: config.sortOrder || '', //排序的顺序
        pageList: [10, 20, 50, 100], // 可选的每页条数
        pageNum: 1, //添加默认分页参数.第一页, 每页共有100条数据
        pageSize: 20,
        toolbar: config.toolbar || '#toolbar',  // 工具栏
        // 动态传递的 loadFilter 函数 数据过滤功能，主要用于将从服务端返回的数据格式化为 EasyUI 识别的标准格式：
        loadFilter: function (data) {
            if (config.loadFilter) {
                config.loadFilter(data);
            }

            // 检查数据格式
            if (data && data.extend && data.extend.pageInfo) {
                let pageInfo = data.extend.pageInfo;
                let footer = data.extend.footer || [];

                //给footer每一项数据添加一个标识
                footer.forEach(item => {
                    item.isFooter = true;
                });

                return {
                    total: pageInfo.total,           // 数据总数
                    rows: pageInfo.list || [],       // 当前页的数据
                    footer: footer                   // 页脚数据
                };
            }

            // 如果数据格式不是预期的格式，尝试其他可能的格式
            if (data && typeof data === 'object') {
                return {
                    total: data.total || 0,
                    rows: Array.isArray(data.rows) ? data.rows :
                          Array.isArray(data) ? data : [],
                    footer: data.footer || []
                };
            }

            // 如果都不匹配，返回空数据
            return {
                total: 0,
                rows: [],
                footer: []
            };
        },
        // 动态传递的 onBeforeLoad 函数
        onBeforeLoad: function (param) {
            // 调整分页参数，确保传递给后端的是自定义的参数名
            param.pageNum = param.page; // 将默认的 page 转换为自定义的 pageNum
            param.pageSize = param.rows; // 将默认的 rows 转换为自定义的 pageSize
            delete param.page; // 删除默认的 page 参数
            delete param.rows; // 删除默认的 rows 参数
            console.log('请求的分页参数：', param);
            if (config.onBeforeLoad) {
                config.onBeforeLoad(param);
            }
        },
        onLoadSuccess: function (data) {
            // 数据加载成功后检查按钮状态
            if (config.onLoadSuccess) {
                config.onLoadSuccess(data);
            }
            // 延迟调用，确保表格渲染完成后再执行按钮状态更新
            setTimeout(() => {
                // 页面加载完成时，初始化按钮状态
                updateButtonState(datagridSelector);
            }, 0);
        },
        onSelect: function (index, row) {
            // 延迟获取选中行数
            setTimeout(function() {
                // 如果是多选模式，选择单行时不执行重复操作
                if ($(datagridSelector).datagrid('getSelections').length === 1) {
                    // alert("onSelect=" + $(datagridSelector).datagrid('getSelections').length)
                    // 当选中一行时，更新按钮状态
                    updateButtonState(datagridSelector);
                }
            }, 0);
        },
        onCheck: function (index, row) {
            // 延迟获取选中行数
            setTimeout(function() {
                // 当多选框勾选时，更新按钮状态
                if ($(datagridSelector).datagrid('getSelections').length === 2) {
                    // alert("onCheck=" + $(datagridSelector).datagrid('getSelections').length)
                    // 当选中多行时，更新按钮状态
                    updateButtonState(datagridSelector);
                }
            }, 0);
        },
        onUnselect: function (index, row) {
            // 延迟获取选中行数
            setTimeout(function() {
                // 当单行被取消选择时更新按钮状态
                if ($(datagridSelector).datagrid('getSelections').length <= 1) {
                    // alert("onUnselect=" + $(datagridSelector).datagrid('getSelections').length)
                    // 当取消单行选择时，更新按钮状态
                    updateButtonState(datagridSelector);
                }
            }, 0);
        },
        onUncheck: function(index, row) {
            // 延迟获取选中行数
            setTimeout(function() {
                // 当单行被取消选择时更新按钮状态
                if ($(datagridSelector).datagrid('getSelections').length === 1) {
                    // alert("onUnCheck=" + $(datagridSelector).datagrid('getSelections').length)
                    // 当取消单行选择时，更新按钮状态
                    updateButtonState(datagridSelector);
                }
            }, 0);
        },
        onCheckAll: function() {//全选
            // alert("全选的行:" + selectedRows.length);
            updateButtonState(datagridSelector);
        },
        onUncheckAll: function() {//全不选
            // alert("全不选后的行:" + selectedRows.length);
            updateButtonState(datagridSelector);
        },
        onSortColumn: function(sort, order) {
            if (config.onSortColumn) {
                config.onSortColumn(sort, order);
            }
            // 捕获用户点击列标题时的排序字段和排序顺序
            console.log('排序字段:', sort, '排序顺序:', order);//排序字段: createTime 排序顺序: desc
        },
        onExpandRow: config.onExpandRow,
        detailFormatter: config.detailFormatter,
    });
}

function initializeTreeGrid(config)  {
    $('#menuTreeGrid').treegrid({
        url: config.url || [],
        method: 'get',
        idField: 'id',
        treeField: 'text',
        columns: config.columns || [],
        fit: true,
        fitColumns: false,
        rownumbers: true,
        fitColumns: true,     // 启用列宽自动适配
        pagination: true,
        singleSelect: true,
        // 动态传递的 loadFilter 函数 数据过滤功能，主要用于将从服务端返回的数据格式化为 EasyUI 识别的标准格式：
        loadFilter: function (data) {
            // 如果是分页数据
            if (data && data.extend && data.extend.pageInfo) {
                let pageInfo = data.extend.pageInfo;

                return {
                    total: pageInfo.total, // 数据总数，用于分页
                    rows: pageInfo.list       // 当前页的数据
                };
            }

            // 如果是简单集合（子节点数据）
            if (Array.isArray(data)) {
                console.log("Array.isArray(data)===", data);

                // 转换子节点集合为 treegrid 识别的格式
                return data.map(menu => ({
                    id: menu.id,
                    parentId: menu.parentId,
                    text: menu.text,
                    url: menu.url,
                    status: menu.status,
                    orderNum: menu.orderNum,
                    remark: menu.remark,
                    state: menu.state, // 根据是否有子节点设置状态
                    hasChildren: menu.hasChildren // 根据是否有子节点设置状态
                }));
            }

            // 如果数据格式不正确，返回空数据
            console.error("数据格式不正确：", data);
            return {
                total: 0,
                rows: []
            };
        },
        onClickRow: function (row) {//点击事件用点击行事件代替
            if (config.onClickRow) {
                config.onClickRow(row);
            }

        },
        onBeforeExpand: function(row) {
            if (config.onBeforeExpand) {
                config.onBeforeExpand(row);
            }

        },
    });
}

// 更新按钮状态的函数
function updateButtonState(datagridSelector = '#datagrid') {
    var selectedRows = $(datagridSelector).datagrid('getSelections');  // 获取所有选中的行
    var selectedRowCount = selectedRows.length;

    if (selectedRowCount === 1) {
        // 选中一条数据时启用按钮
        //如果有enable函数就调用,没有就不调用
        if (typeof enable === 'function') {
            enable();
        }
        // enable();
    } else {
        // 没有选中时禁用按钮
        // 选中多条数据时禁用按钮
        if (typeof disable === 'function') {
            disable();
        }
        // disable();
    }
}

/**
 * 重置查询条件，根据传入的配置自定义行为
 * @param {Object} options - 配置对象
 * @param {Array} [options.excludeIds=[]] - 需要保留不清空的输入框的ID数组
 * @param {Object} [options.setValues={}] - 需要设置值的输入框的ID和值的键值对
 * @param {Boolean} [options.reload=true] - 是否触发表格刷新
 * @param {String} [options.datagridSelector='#datagrid'] - datagrid选择器
 */
function resetSearch(options = {}) {
    const {
        excludeIds = [],
        setValues = {},
        reload = true,
        datagridSelector = '#datagrid'
    } = options;

    // 重置表单中的输入元素
    $('#searchForm').find('input, select, textarea').each(function () {
        const element = $(this);
        const elementId = element.attr('id');

        if (elementId && excludeIds.includes(elementId)) {
            return; // 跳过当前元素
        }

        if (element.hasClass('easyui-textbox')) {
            element.textbox('clear');
        } else if (element.hasClass('easyui-combobox')) {
            element.combobox('clear');
        } else if (element.hasClass('easyui-datebox')) {
            element.datebox('clear');
        }
    });

    // 设置指定输入框的值
    for (const [id, value] of Object.entries(setValues)) {
        const element = $('#' + id);
        if (element.length) {
            if (element.hasClass('easyui-textbox')) {
                element.textbox('setValue', value);
            } else if (element.hasClass('easyui-combobox')) {
                element.combobox('setValue', value);
            } else if (element.hasClass('easyui-datebox')) {
                element.datebox('setValue', value);
            } else {
                element.val(value);
            }
        }
    }

    // 根据需要触发表格刷新
    if (reload) {
        // 收集保留字段的当前值
        const queryParams = {};

        // 从 excludeIds 收集当前值
        excludeIds.forEach(id => {
            const element = $('#' + id);
            if (element.length) {
                let value;
                if (element.hasClass('easyui-textbox')) {
                    value = element.textbox('getValue');
                } else if (element.hasClass('easyui-combobox')) {
                    value = element.combobox('getValue');
                } else if (element.hasClass('easyui-datebox')) {
                    // 处理日期范围
                    const dateVal = element.datebox('getValue');
                    if (dateVal && dateVal.includes(' - ')) {
                        const dates = dateVal.split(' - ');
                        queryParams[id + 'Start'] = dates[0];
                        queryParams[id + 'End'] = dates[1];
                    } else {
                        queryParams[id] = dateVal;
                    }
                }
                if (value !== undefined && value !== null && value !== '') {
                    queryParams[id] = value;
                }
            }
        });

        // 合并 setValues，这些值会覆盖从 excludeIds 收集的值（如果有冲突）
        Object.assign(queryParams, setValues);

        // 重新加载数据表格，传递查询参数
        $(datagridSelector).datagrid('load', queryParams);
    }
}

// 查询数据函数
function searchData(options = {}) {
    const {
        condition = false,   // condition标识是否必须要携带查询条件 标识符. 如果为false, 不对查询条件做检查; 如果为true, 检查查询条件.
        setValues = {},
        datagridSelector = '#datagrid'
    } = options;

    var hasCondition = false; // 标记是否有查询条件

    // 获取查询条件的值（表单序列化）
    var serialize = $('#searchForm').serialize().split('&');
    // console.log("serialize==========", serialize);
    // 将序列化的查询条件转成对象格式
    var queryParams = {};
    queryParams.params = typeof (queryParams.params) === 'object' && queryParams.params !== null && !Array.isArray(queryParams.params) ? queryParams.params : {};
    serialize.forEach(function (item) {
        var [key, value] = item.split('=');

        value = decodeURIComponent(value);
        // 检查是否为日期范围字段
        if (value.includes(' - ')) {
            // 分解日期范围
            var [startDate, endDate] = value.split(' - ');
            queryParams.params[key + 'Start'] = startDate;
            queryParams.params[key + 'End'] = endDate;
        } else if (value && value !== '') {
            // 普通字段直接添加, 筛选掉空值和空串
            queryParams[key] = value;
            hasCondition = true; // 存在有效条件
        }
    });

    // 如果没有条件则提示用户，并终止查询
    if (condition && !hasCondition) {
        alert('请至少填写一个查询条件！');
        return;
    }

    // 遍历对象, 设置指定的值
    for (const [key, value] of Object.entries(setValues)) {
        queryParams[key] = value;
    }

    console.log("queryParams====>", queryParams);


    // 重新加载表格数据，传递查询条件

    // load() 期望对象格式：datagrid('load', params) 中的 params 必须是一个 JavaScript 对象

    //load 方法
    //使用新的查询参数重新加载数据网格的内容。
    //可以传递查询参数，替换网格的当前查询参数。

    //当 reload 方法带参数时：
    // 它会 合并当前网格的已有查询参数 和 新传递的参数，然后重新加载数据。
    // 如果传递的参数中有与已有参数重名的键，则会覆盖已有参数。

    // 如果是 GET 请求，datagrid 会把对象转换为查询字符串（?rejectReason=xxx&createTime=2024-12-01）并将其附加到 URL 中。
    // 如果是 POST 请求，datagrid 会将这个对象作为请求体发送 rejectReason=&createTime=2024-12-04&pageNum=1&pageSize=10
    $(datagridSelector).datagrid('reload', queryParams);
}
